Nous avons à notre disposition les images de races de chiens issues du site de Standford
http://vision.stanford.edu/aditya86/ImageNetDogs/Nous devons modéliser l'indexation des images de façon à pouvoir identifier la race du chien sur une image donnée.
Nous traitons ici de la méthode de Vision par Ordinateur Traditionnelle
import os
import mes_fonctions as stt
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime
from PIL import Image
import cv2
import imp
imp.reload(stt)
path_images = '../PROJET/data/data/Images'
Ce fichier est composé de :
# Chargement du DataSet
desc = pd.read_csv('output/Descriptions.csv', index_col='file')
On sépare les données à partir de Desc
Optionnel : on filtre sur une liste de races de chiens
On récupère le fichier de description divisé en 2 : train / test
# Répartition en train / test
## Nous prenons ici uniquement 6 races de chiens
desc_train, desc_test = stt.repartition_data_train_test_by_liste(desc, ratio_train=0.8, liste=stt.liste_6_races)
def get_path_from(name, path='../PROJET/data/data/Images'):
info = desc_train.loc['n02115641_7071']
return path + '/' + info.subpath + '/' + info.name + '.jpg'
a.head()
path1 = '../PROJET/data/data/Images'
u1 = cv2.imread(path1+'/'+'n02097658-silky_terrier'+'/'+'n02097658_271.jpg', 0)
print('Nous disposons de {nb_race} races.'.format(nb_race=desc.race.nunique()))
print('Nous disposons de {nb_chien} images de chiens.'.format(nb_chien=desc.shape[0]))
freq = desc.groupby(by=['race']).size().reset_index(name='Freq')
freq.sort_values(by='Freq', ascending=False, inplace=True)
freq.head()
freq.tail()
u = stt.info_size(desc)
u.describe()
desc_train, desc_test = stt.repartition_data_train_test_by_liste(desc, ratio_train=0.8, liste=stt.liste_6_races)
freq = desc_train.groupby(by=['race']).size().reset_index(name='Freq')
freq.sort_values(by='Freq', ascending=False, inplace=True)
freq
stt.info_size(desc_train).describe()
Nous pouvons mettre toutes les images à la taille : 280 x 280 (qui est la moyenne)
Nous allons appliquer différents traitements d'images à celles-ci
- Transformation en niveau de gris de l'image
- Un filtre Gaussien de Floutage pour débruiter celle-ci, via 2 paramètres :
- la taille du noyau de filtrage BLUR_SIZE
- l'écart type du filtre
- Un crop selon les données disponible sur les infos de chaque fichiers
- Une égalisation de l'histogramme
- Un resize pour mettre toutes les images à une même taille
- Ensuite nous mettons en vecteur les valeurs des intensités des images
/!\ La fonction 'Copy Into' permet de faire un resize de l'image en mettant un bord noir afin de conserver le ratio largeur / hauteur, tout en minimisant le nombre de pixel noirs.
imp.reload(stt)
stt.affiche_images(name1 = 'n02115641_7071', desc_train=desc, path1=path1)
stt.affiche_images(name1 = 'n02113712_3261', desc_train=desc, path1=path1)
stt.affiche_images(name1 = 'n02113978_3822', desc_train=desc, path1=path1)
stt.affiche_images(name1 = 'n02116738_7008', desc_train=desc, path1=path1)
stt.affiche_images(name1 = 'n02115913_2480', desc_train=desc, path1=path1)
stt.affiche_images(name1 = 'n02113712_3120', desc_train=desc, path1=path1)
def ajoute_kp_SIFT(image):
sift = cv2.xfeatures2d.SIFT_create()
kp = sift.detect(image, None)
img=cv2.drawKeypoints(image,kp,image,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
return img
stt.affiche_images(name1 = 'n02115641_7071', desc_train=desc, path1=path1, transfo_image=ajoute_kp_SIFT)
stt.affiche_images(name1 = 'n02113712_3261', desc_train=desc, path1=path1, transfo_image=ajoute_kp_SIFT)
stt.affiche_images(name1 = 'n02113978_3822', desc_train=desc, path1=path1, transfo_image=ajoute_kp_SIFT)
stt.affiche_images(name1 = 'n02116738_7008', desc_train=desc, path1=path1, transfo_image=ajoute_kp_SIFT)
stt.affiche_images(name1 = 'n02115913_2480', desc_train=desc, path1=path1, transfo_image=ajoute_kp_SIFT)
stt.affiche_images(name1 = 'n02113712_3120', desc_train=desc, path1=path1, transfo_image=ajoute_kp_SIFT)
Si on s'attache à identifier des points clefs sur les oreilles, la truffe, les pates, les yeux etc.. on s'aperçoit que ce sont les 2 dernières versions qui arrive à identifier ces points.
On s'aperçoit que l'égalisation d'histogramme ajoute un grand nombre de features clefs sur l'arrière plan, et perd
On note que la dernière image semble supprimer plus de faux points clefs, mais c'est peut-être du hasard.
Il faudra donc conserver
- des valeurs d'écart-type du noyau Gaussien de 0.5 et 1.0
- appliquer un crop
- ne pas faire d'équalisation d'histogramme
- faire un resize into (ajouter un cadre noir pour les partie autres que l'image) mais ne supprime pas les rapport hauteur/largeure
def create_image_matrix(desc, ):
l_np_image = []
SIZE = (280, 280)
for image_name in desc.index.tolist():
m_image = stt.transforme_image(
desc=desc, name=image_name, rep_path=path1,
is_crop=True, is_resize=True, is_blur=True,
is_Inline=True, BLUR_SIZE=5, BLUR_SIGMAX=1.0,
is_equalizeHist=False, is_resize_into=True,
SIZE_GLOBAL=SIZE
)
l_np_image.append(m_image)
return l_np_image
debut = datetime.now()
u_train = create_image_matrix(desc_train)
u_train = np.array(u_train)
fin = datetime.now()
print('Tps Fabrication Matrice Image : ', fin-debut)
debut = datetime.now()
u_test = create_image_matrix(desc_test)
u_test = np.array(u_test)
fin = datetime.now()
print('Tps Fabrication Matrice Image : ', fin-debut)
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
def creation_datas_pca(desc, matrice_image):
'''Fabrication d'un df PCA, et d'un vecteur de race'''
std = StandardScaler()
x0 = std.fit_transform(matrice_image)
pca = PCA(n_components=10)
X = pca.fit_transform(x0)
le = LabelEncoder()
Y = le.fit_transform(desc.race)
return X, Y
debut = datetime.now()
x_1, y_1 = creation_datas(desc_train, u_train)
fin = datetime.now()
print('Tps Creation PCA: ', fin-debut)
x_1 = pd.DataFrame(x_1)
x_1.head()
plt.figure(figsize=(17, 15))
idx = 0
for i in range(0,5):
for j in range(i+1, 5):
idx+=1
plt.subplot(4, 3, idx)
plt.scatter(x=x_1[i], y=x_1[j], c=y_1, cmap='Set1')
plt.title('PCA{} / PCA{}'.format(i, j))
plt.colorbar()
#plt.colorbar.set_label('Races des chiens')
plt.suptitle('PCA des Images selon les races')
plt.show()
def creation_datas_tsne(desc, matrice_image):
'''Fabrication d'un df PCA, et d'un vecteur de race'''
std = StandardScaler()
x0 = std.fit_transform(matrice_image)
tsne = TSNE()
X = tsne.fit_transform(x0)
le = LabelEncoder()
Y = le.fit_transform(desc.race)
return X, Y
debut = datetime.now()
x_2, y_2 = creation_datas(desc_train, u_train)
fin = datetime.now()
print('Tps Creation TSNE: ', fin-debut)
x_2 = pd.DataFrame(x_2)
plt.figure(figsize=(10, 5))
plt.scatter(x=x_2[0], y=x_2[1], c=y_2, cmap='Set1')
plt.colorbar()
plt.title('TSNE des Images selon les races')
plt.show()
Ces réduction n'apporte à priori pas d'information sur les regroupements de races
Un tsne n'apporte pas plus d'information ici
Ce traitement permet d'apporter un lissage des bruits blancs sur l'ensemble des images
Regardons si cela semble apporter quelque chose dans notre cas
def whitening(X, epsilon=0.1):
X_norm = X / 255.
cov = np.cov(X_norm, rowvar=True)
U,S,V = np.linalg.svd(cov)
MAT1 = U.dot(np.diag(1.0/np.sqrt(S + epsilon))).dot(U.T)
#X_ZCA = U.dot(np.diag(1.0/np.sqrt(S + epsilon))).dot(U.T).dot(X_norm)
X_ZCA = MAT1.dot(X_norm)
X_ZCA_rescaled = (X_ZCA - X_ZCA.min()) / (X_ZCA.max() - X_ZCA.min())
###X_ZCA_rescaled = pd.DataFrame(np.uint8(X_ZCA_rescaled*255), index=desc_train.index)
return MAT1, X_ZCA_rescaled
u_train = pd.DataFrame(np.uint8(u_train), index=desc_train.index)
#IMAGE_NAME = 'n02113712_3120'
def affiche_diff_avec_sans_whitening(IMAGE_NAME,u_train, u_train_whit):
try:
plt.figure(figsize=(10, 10))
plt.subplot(121)
plt.imshow(ajoute_kp_SIFT(u_train.loc[IMAGE_NAME].values.reshape(280, 280)), cmap='gray')
plt.title('Sans Whitening')
plt.subplot(122)
plt.imshow(ajoute_kp_SIFT(u_train_whit.loc[IMAGE_NAME].values.reshape(280, 280)), cmap='gray')
plt.title('Avec Whitening')
plt.show()
except:
print("Erreur sur l'image : {}".format(IMAGE_NAME))
debut = datetime.now()
M1, u_train_whit = whitening(u_train, epsilon=1.5)
u_train_whit = pd.DataFrame(np.uint8(u_train_whit*255), index=desc_train.index)
fin = datetime.now()
print('Tps Whitening: ', fin-debut)
affiche_diff_avec_sans_whitening('n02115641_7071', u_train, u_train_whit)
#affiche_diff_avec_sans_whitening('n02113712_3261', u_train, u_train_whit)
affiche_diff_avec_sans_whitening('n02113978_3822', u_train, u_train_whit)
#affiche_diff_avec_sans_whitening('n02116738_7008', u_train, u_train_whit)
#affiche_diff_avec_sans_whitening('n02115913_2480', u_train, u_train_whit)
affiche_diff_avec_sans_whitening('n02113712_3120', u_train, u_train_whit)
Le whitening semble supprimer du bruit causé par les informations de second plan tout en conservant les features de l'image
def whitening_for_test(X, MAT1):
X_norm = X / 255.
X_ZCA = MAT1.dot(X_norm)
X_ZCA_rescaled = (X_ZCA - X_ZCA.min()) / (X_ZCA.max() - X_ZCA.min())
return np.uint8(X_ZCA_rescaled*255)
u_test_whitening = whitening_for_test(u_test, M1[:190, :190])
u_test_whitening = pd.DataFrame(u_test_whitening, index=desc_test.index)
u_test = pd.DataFrame(u_test, index=desc_test.index)
#affiche_diff_avec_sans_whitening('n02115641_7071', u_test, u_test_whitening)
affiche_diff_avec_sans_whitening('n02113712_3261', u_test, u_test_whitening)
#affiche_diff_avec_sans_whitening('n02113978_3822', u_test, u_test_whitening)
affiche_diff_avec_sans_whitening('n02116738_7008', u_test, u_test_whitening)
affiche_diff_avec_sans_whitening('n02115913_2480', u_test, u_test_whitening)
#affiche_diff_avec_sans_whitening('n02113712_3120', u_test, u_test_whitening)
def normalize_SIFT(m_desc_sift):
# On applique une normalisation Euclidienne
tmp1 = m_desc_sift / np.sqrt(np.sum(np.square(m_desc_sift), axis=0))
# On seuil les valeurs à 0.2
tmp1 = np.where(tmp1>0.2, 0.2, tmp1)
# On applique a nouveau une normalisation euclidienne
tmp1 = tmp1 / np.sqrt(np.sum(np.square(tmp1), axis=0))
return tmp1
def detect_SIFT(image_matrix, image_nb, IMAGE_SIZE = ( 280, 280,)):
u1 = np.uint8(image_matrix[image_nb].reshape(IMAGE_SIZE))
sift = cv2.xfeatures2d.SIFT_create()
_, des1 = sift.detectAndCompute(u1, None)
return normalize_SIFT(des1)
m_x1 = np.uint8(u_train_whit)
l_desc_sift = []
debut = datetime.now()
for image_nb in range(0,m_x1.shape[0]):
tmp1 = pd.DataFrame(detect_SIFT(m_x1, image_nb, IMAGE_SIZE=( 280, 280,)))
tmp1['Image_nb'] = image_nb
l_desc_sift.append(tmp1)
fin = datetime.now()
print('Tps Extraction SIFT DESCRIPTEURS: ', fin-debut)
df_descripteur_SIFT_train = pd.concat(l_desc_sift)
df_descripteur_SIFT_train.fillna(value=0, inplace=True)
df_descripteur_SIFT_train.reset_index(drop=True, inplace=True)
Nous voulons faire des clusters de ces features afin de regrouper les features qui se 'ressemblent'
Le centroïd de ces clusters sera la features 'moyenne'
from sklearn.cluster import MiniBatchKMeans
def genere_cluster_from_features(df_features_SIFT):
kmeans = MiniBatchKMeans(n_clusters=20)
kmeans.fit_transform(df_descripteur_SIFT_train[df_descripteur_SIFT_train.columns[:-1]])
return kmeans
debut = datetime.now()
# Il faut optimiser selon les silhouettes
m_kmeans = genere_cluster_from_features(df_descripteur_SIFT_train[df_descripteur_SIFT_train.columns[:-1]])
fin = datetime.now()
print('Tps Extraction SIFT DESCRIPTEURS: ', fin-debut)
def identify_best_MiniBatchKmeans_ClusterNumber(X, cluster_range=range(10, 81, 10)):
from sklearn.cluster import MiniBatchKMeans
from sklearn.model_selection import GridSearchCV
#from sklearn.metrics import silhouette_score
m_param_grid={'n_clusters': list(cluster_range)}
gs = GridSearchCV(MiniBatchKMeans(),
param_grid=m_param_grid, cv=7, refit=True,
return_train_score=True, )
gs.fit(X)
print('Le meilleur nombre de cluster est : ', gs.best_params_['n_clusters'])
return gs
debut = datetime.now()
gs = identify_best_MiniBatchKmeans_ClusterNumber(
df_descripteur_SIFT_train[df_descripteur_SIFT_train.columns[:-1]],
cluster_range=range(10, 81, 10),
)
fin = datetime.now()
print('Tps Test CLUSTERING: ', fin-debut)
debut = datetime.now()
gs = identify_best_MiniBatchKmeans_ClusterNumber(
df_descripteur_SIFT_train[df_descripteur_SIFT_train.columns[:-1]],
cluster_range=range(60, 91, 4),
)
fin = datetime.now()
print('Tps Test CLUSTERING: ', fin-debut)
#T1 = df_descripteur_SIFT_train[df_descripteur_SIFT_train.columns[:-1]].loc[0]
#gs.predict([T1])
def genere_histogramme(X, Labels, range_cluster=range(72)):
repartition_features = pd.DataFrame({'Images_nb': X.Image_nb, 'Cluster':Labels})
tmp = repartition_features.groupby(by=['Images_nb', 'Cluster']).size().reset_index(name='Freq')
tmp = tmp.pivot_table(index=['Images_nb'],columns=['Cluster'],values=['Freq'],fill_value=0)
tmp.columns = tmp.columns.droplevel(level=0)
if (tmp.shape[1]!=len(range_cluster)):
# On ajoute les colonnes manquantes
col_manquante = list(set(range_cluster)-set(tmp.columns))
for co in col_manquante:
tmp[co] = 0
tmp = tmp[list(range_cluster)]
tmp = pd.DataFrame(normalize_SIFT(tmp), index=tmp.index)
return tmp
histo = genere_histogramme(
df_descripteur_SIFT_train,
gs.best_estimator_.labels_
)
histo.head()
Notre variable histo est l'histogramme des descripteurs SIFT normalisés et seuillés.
C'est donc notre feature d'entrée pour modéliser notre problème
Nous allons réaliser une réduction dimensionnelle afin de visualiser nos images pour modéliser notre problématique.
std = StandardScaler()
x0 = std.fit_transform(histo)
pca = PCA(n_components=72)
X = pca.fit_transform(x0)
le = LabelEncoder()
Y = le.fit_transform(desc_train.race)
X = pd.DataFrame(X)
plt.figure(figsize=(17, 15))
idx = 0
for i in range(0,5):
for j in range(i+1, 5):
idx+=1
plt.subplot(4, 3, idx)
plt.scatter(x=X[i], y=X[j], c=Y, cmap='Set1')
plt.title('PCA{} / PCA{}'.format(i, j))
plt.colorbar()
#plt.colorbar.set_label('Races des chiens')
plt.suptitle('PCA des Images selon les races')
plt.show()
On applique le PCA et on ajoute les puissance de 2
u = np.array([X[0], X[0]**2, X[0]**3, X[1], X[1]**2, X[1]**3, X[2], X[2]**2, X[2]**3,])
Y.shape, u.shape
from sklearn.svm import SVC
clf = SVC()
clf.fit(pd.DataFrame(u).T, Y)
clf.score(pd.DataFrame(u).T, Y)
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(n_estimators=7000, max_depth=20, random_state=0)
clf.fit(pd.DataFrame(u).T, Y)
clf.score(pd.DataFrame(u).T, Y)
m_X.shape, m_y.shape
plt.scatter(x=(X[0]**1), y=X[1]**1, c=Y, cmap='Set1')
#plt.scatter(x=(X[1]**1), y=X[2]**1, c=Y, cmap='Set1')
plt.show()
tsne = TSNE(n_components=2, )
debut = datetime.now()
X_tsne = tsne.fit_transform(x0)
fin = datetime.now()
print('Tps TSNE: ', fin-debut)
X_tsne = pd.DataFrame(X_tsne)
plt.figure(figsize=(10, 5))
plt.scatter(x=X_tsne[1], y=X_tsne[2], c=Y, cmap='Set1')
plt.colorbar()
plt.title('TSNE des Images selon les races')
plt.show()
from sklearn.manifold import Isomap
debut = datetime.now()
embedding = Isomap(n_components=5)
###X_transformed = embedding.fit_transform(x0)
###### ATTENTION X est un PCA
X_transformed = embedding.fit_transform(X)
fin = datetime.now()
print('Tps TSNE: ', fin-debut)
### ON AFFICHE
X_transformed = pd.DataFrame(X_transformed)
plt.figure(figsize=(17, 15))
idx = 0
for i in range(0,5):
for j in range(i+1, 5):
idx+=1
plt.subplot(4, 3, idx)
plt.scatter(x=X_transformed[i], y=X_transformed[j], c=Y, cmap='Set1')
plt.title('ISOMAP{} / ISOMAP{}'.format(i, j))
plt.colorbar()
#plt.colorbar.set_label('Races des chiens')
plt.suptitle('ISOMAP des Images selon les races')
plt.show()
from sklearn.manifold import LocallyLinearEmbedding
debut = datetime.now()
embedding = LocallyLinearEmbedding(n_components=10, n_neighbors=10)
X_transformed = embedding.fit_transform(x0)
fin = datetime.now()
print('Tps LLE: ', fin-debut)
### ON AFFICHE
X_transformed = pd.DataFrame(X_transformed)
plt.figure(figsize=(17, 15))
idx = 0
for i in range(0,5):
for j in range(i+1, 5):
idx+=1
plt.subplot(4, 3, idx)
plt.scatter(x=X_transformed[i], y=X_transformed[j], c=Y, cmap='Set1')
plt.title('LLE{} / LLE{}'.format(i, j))
plt.colorbar()
#plt.colorbar.set_label('Races des chiens')
plt.suptitle('LLE des Images selon les races')
plt.show()
np.sum((X_transformed[0]>-0.04) & (X_transformed[1]<0.01))
from sklearn.manifold import MDS
debut = datetime.now()
embedding = MDS(n_components=10, )
X_transformed = embedding.fit_transform(x0)
fin = datetime.now()
print('Tps MDS: ', fin-debut)
### ON AFFICHE
X_transformed = pd.DataFrame(X_transformed)
plt.figure(figsize=(17, 15))
idx = 0
for i in range(0,5):
for j in range(i+1, 5):
idx+=1
plt.subplot(4, 3, idx)
plt.scatter(x=X_transformed[i], y=X_transformed[j], c=Y, cmap='Set1')
plt.title('MDS{} / MDS{}'.format(i, j))
plt.colorbar()
#plt.colorbar.set_label('Races des chiens')
plt.suptitle('MDS des Images selon les races')
plt.show()
plt.figure(figsize=(10, 5))
plt.scatter(x=X_transformed[0], y=X_transformed[1], c=Y, cmap='Set1')
#plt.plot([-0.06, 0.00], [-0.02, 0.02], )
plt.colorbar()
plt.title('MDS des Images selon les races')
plt.show()
Nous allons faire une fonction qui va résumer les opérations
Nous les relancerons sur des DataSet plus importants ensuite
def normalize_SIFT(m_desc_sift):
# On applique une normalisation Euclidienne
tmp1 = m_desc_sift / np.sqrt(np.sum(np.square(m_desc_sift), axis=0))
# On seuil les valeurs à 0.2
tmp1 = np.where(tmp1>0.2, 0.2, tmp1)
# On applique a nouveau une normalisation euclidienne
tmp1 = tmp1 / np.sqrt(np.sum(np.square(tmp1), axis=0))
return tmp1
def detect_SIFT(image_matrix, image_nb, IMAGE_SIZE = ( 280, 280,)):
u1 = np.uint8(image_matrix[image_nb].reshape(IMAGE_SIZE))
sift = cv2.xfeatures2d.SIFT_create()
_, des1 = sift.detectAndCompute(u1, None)
return normalize_SIFT(des1)
def genere_histogramme(X, Labels, range_cluster=range(72)):
repartition_features = pd.DataFrame({'Images_nb': X.Image_nb, 'Cluster':Labels})
tmp = repartition_features.groupby(by=['Images_nb', 'Cluster']).size().reset_index(name='Freq')
tmp = tmp.pivot_table(index=['Images_nb'],columns=['Cluster'],values=['Freq'],fill_value=0)
tmp.columns = tmp.columns.droplevel(level=0)
if (tmp.shape[1]!=len(range_cluster)):
# On ajoute les colonnes manquantes
col_manquante = list(set(range_cluster)-set(tmp.columns))
for co in col_manquante:
tmp[co] = 0.01
tmp = tmp[list(range_cluster)]
tmp = pd.DataFrame(normalize_SIFT(tmp), index=tmp.index)
return tmp
def detect_SIFT(image_matrix, image_nb, IMAGE_SIZE = ( 280, 280,)):
u1 = np.uint8(image_matrix[image_nb].reshape(IMAGE_SIZE))
sift = cv2.xfeatures2d.SIFT_create()
_, des1 = sift.detectAndCompute(u1, None)
return normalize_SIFT(des1)
def detect_SURF(image_matrix, image_nb, IMAGE_SIZE = ( 280, 280,)):
u1 = np.uint8(image_matrix[image_nb].reshape(IMAGE_SIZE))
surf = cv2.xfeatures2d.SURF_create()
_, des1 = surf.detectAndCompute(u1, None)
return normalize_SIFT(des1)
def detect_ORB(image_matrix, image_nb, IMAGE_SIZE = ( 280, 280,)):
u1 = np.uint8(image_matrix[image_nb].reshape(IMAGE_SIZE))
orb = cv2.ORB_create()
kp = orb.detect(u1,None)
_, des1 = orb.compute(u1, kp)
if des1 is None:
return 0.01*np.ones(32).reshape(1,-1)
else:
return normalize_SIFT(des1)
def detect_BRIEF(image_matrix, image_nb, IMAGE_SIZE = ( 280, 280,)):
u1 = np.uint8(image_matrix[image_nb].reshape(IMAGE_SIZE))
star = cv2.xfeatures2d.StarDetector_create()
brief = cv2.xfeatures2d.BriefDescriptorExtractor_create()
kp = star.detect(u1,None)
_, des1 = brief.compute(u1, kp)
if des1 is None:
return 0.01*np.ones(32).reshape(1,-1)
else:
return normalize_SIFT(des1)
def whitening(X, epsilon=0.1):
X_norm = X / 255.
cov = np.cov(X_norm, rowvar=True)
U,S,V = np.linalg.svd(cov)
MAT1 = U.dot(np.diag(1.0/np.sqrt(S + epsilon))).dot(U.T)
#X_ZCA = U.dot(np.diag(1.0/np.sqrt(S + epsilon))).dot(U.T).dot(X_norm)
X_ZCA = MAT1.dot(X_norm)
X_ZCA_rescaled = (X_ZCA - X_ZCA.min()) / (X_ZCA.max() - X_ZCA.min())
X_ZCA_rescaled = np.uint8(X_ZCA_rescaled*255)
return X_ZCA_rescaled
def create_image_matrix(desc, BLUR_SIGMAX=1.0):
l_np_image = []
SIZE = (280, 280)
for image_name in desc.index.tolist():
m_image = stt.transforme_image(
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=True,
is_resize_into=False,
SIZE_GLOBAL=SIZE
)
l_np_image.append(m_image)
return l_np_image
def generation_df_SIFT(x_train, SIZE):
l_desc_sift = []
for image_nb in range(0,x_train.shape[0]):
tmp1 = pd.DataFrame(detect_SIFT(x_train, image_nb, IMAGE_SIZE=SIZE))
tmp1['Image_nb'] = image_nb
l_desc_sift.append(tmp1)
df_descripteur_SIFT = pd.concat(l_desc_sift)
df_descripteur_SIFT.fillna(value=0, inplace=True)
df_descripteur_SIFT.reset_index(drop=True, inplace=True)
return df_descripteur_SIFT
def generation_df_XXXX(x_train, SIZE, METHOD='SIFT'):
l_desc_XXX = []
for image_nb in range(0,x_train.shape[0]):
if METHOD=='SIFT':
tmp1 = pd.DataFrame(detect_SIFT(x_train, image_nb, IMAGE_SIZE=SIZE))
elif METHOD=='SURF':
tmp1 = pd.DataFrame(detect_SURF(x_train, image_nb, IMAGE_SIZE=SIZE))
elif METHOD=='ORB':
tmp1 = pd.DataFrame(detect_ORB(x_train, image_nb, IMAGE_SIZE=SIZE))
else:
tmp1 = pd.DataFrame(detect_BRIEF(x_train, image_nb, IMAGE_SIZE=SIZE))
tmp1['Image_nb'] = image_nb
l_desc_XXX.append(tmp1)
df_descripteur_XXX = pd.concat(l_desc_XXX)
df_descripteur_XXX.fillna(value=0, inplace=True)
df_descripteur_XXX.reset_index(drop=True, inplace=True)
return df_descripteur_XXX
def identify_best_Kmeans_ClNb(X, cluster_range=range(10, 81, 10)):
from sklearn.cluster import MiniBatchKMeans
from sklearn.model_selection import GridSearchCV
m_param_grid={'n_clusters': list(cluster_range)}
gs = GridSearchCV(MiniBatchKMeans(),
param_grid=m_param_grid, cv=3, refit=True,
return_train_score=True, )
gs.fit(X[X.columns[:-1]])
print('Le meilleur nombre de cluster est : ', gs.best_params_['n_clusters'])
return gs
def fabrication_Histogramme_from_Feature(
z_train, z_test,
SIZE=( 280, 280,), METHOD='SIFT',
cluster_range=range(60, 91, 4)):
'''Fonction qui renvoie l'histogramme Train/Test pour la méthode de Feature donnée'''
# 1 - Extraction des Features
df_descripteur_XXX_train = generation_df_XXXX(z_train, SIZE=SIZE, METHOD=METHOD)
df_descripteur_XXX_test = generation_df_XXXX(z_test, SIZE=SIZE, METHOD=METHOD)
# 2 - Identification des K-Means
gs_train_XXX = identify_best_Kmeans_ClNb(
df_descripteur_XXX_train, cluster_range=cluster_range)
Label_test_XXX = gs_train_XXX.predict(
df_descripteur_XXX_test[df_descripteur_XXX_test.columns[:-1]])
# 3 - Génération des Histogramme
histo_train_XXX = genere_histogramme(df_descripteur_XXX_train, gs_train_XXX.best_estimator_.labels_)
histo_test_XXX = genere_histogramme(df_descripteur_XXX_test, Label_test_XXX)
print('METHODE {} - Nb de valeurs Nulles {} -- {}'.format(
METHOD,
np.sum(np.sum(X_train.isnull(), axis=0)),
np.sum(np.sum(X_test.isnull(), axis=0)) ))
print('\t-> X_train.shape = {} -- X_test.shape = {}'.format(X_train.shape, X_test.shape))
return histo_train_XXX, histo_test_XXX
def Programme_general_V4(desc_train, desc_test):
# Etape 1 : On met toutes les images dans une même matrice
####### CREATION DES MATRICES D'IMAGES
## Pour le Train
debut = datetime.now()
u_train = create_image_matrix(desc_train, BLUR_SIGMAX=0.5)
u_train = np.array(u_train)
## Pour le Test
# On Applique du Whitening sur le DataSet
u_test = create_image_matrix(desc_test, BLUR_SIGMAX=0.5)
u_test = np.array(u_test)
fin = datetime.now()
print('Tps Création Matrices Images: ', fin-debut)
debut = datetime.now()
u_train_whit = whitening(u_train, epsilon=1.5)
u_test_whit = whitening(u_test, epsilon=1.5)
####u_train_whit = u_train
####u_test_whit = u_test
fin = datetime.now()
print('Tps Whitening: ', fin-debut)
####### GENERATION DES HISTOGRAMMES
### SIFT
debut = datetime.now()
######return u_train_whit, u_test_whit
histo_train_SIFT, histo_test_SIFT = fabrication_Histogramme_from_Feature(
u_train_whit, u_test_whit, SIZE=( 280, 280,), METHOD='SIFT',
cluster_range=range(60, 91, 4))
fin = datetime.now()
print('\t->Histo SIFT : ', fin-debut)
debut = datetime.now()
histo_train_SURF, histo_test_SURF = fabrication_Histogramme_from_Feature(
u_train_whit, u_test_whit, SIZE=( 280, 280,), METHOD='SURF',
cluster_range=range(60, 91, 4))
fin = datetime.now()
print('\t->Histo SURF : ', fin-debut)
#### ON ARRIVE A 60 DONC ON RECOMMENCE A TESTER A 40
debut = datetime.now()
histo_train_ORB, histo_test_ORB = fabrication_Histogramme_from_Feature(
u_train_whit, u_test_whit, SIZE=( 280, 280,), METHOD='ORB',
cluster_range=range(40, 91, 10))
fin = datetime.now()
print('\t->Histo ORB : ', fin-debut)
debut = datetime.now()
histo_train_BRIEF, histo_test_BRIEF = fabrication_Histogramme_from_Feature(
u_train_whit, u_test_whit, SIZE=( 280, 280,), METHOD='BRIEF',
cluster_range=range(80, 101, 10))
fin = datetime.now()
print('\t->Histo BRIEF : ', fin-debut)
######## FABRICATION des Histogrammes GLOBAUX
histo_train = pd.concat([histo_train_SIFT,
histo_train_SURF,
histo_train_ORB,
histo_train_BRIEF], axis=1)
histo_test = pd.concat([histo_test_SIFT,
histo_test_SURF,
histo_test_ORB,
histo_test_BRIEF], axis=1)
return histo_train, histo_test
debut0 = datetime.now()
X_train, X_test = Programme_general_V4(
desc_train=desc_train, desc_test=desc_test)
fin0 = datetime.now()
print('Tps GLOBAL: ', fin0-debut0)
X_train.fillna(value=0, inplace=True)
X_test.fillna(value=0, inplace=True)
from sklearn.feature_extraction.text import TfidfTransformer
tfidf = TfidfTransformer(use_idf=True)
X_train_tf = tfidf.fit_transform(X_train).todense()
X_test_tf = tfidf.transform(X_test).todense()
X_train.to_csv('output/I_X_train.csv', index=False)
X_test.to_csv('output/I_X_test.csv', index=False)
std = StandardScaler()
x0 = std.fit_transform(X_train)
x0_test = std.transform(X_test)
pca = PCA(n_components=72)
X = pca.fit_transform(x0)
X_t = pca.transform(x0_test)
le = LabelEncoder()
Y = le.fit_transform(desc_train.race)
Y_t = le.fit_transform(desc_test.race)
X = pd.DataFrame(X)
X_t = pd.DataFrame(X_t)
plt.figure(figsize=(17, 15))
idx = 0
for i in range(0,5):
for j in range(i+1, 5):
idx+=1
plt.subplot(4, 3, idx)
plt.scatter(x=X[i], y=X[j], c=Y, cmap='Set1')
plt.title('PCA{} / PCA{}'.format(i, j))
plt.colorbar()
#plt.colorbar.set_label('Races des chiens')
plt.suptitle('PCA des Images selon les races')
plt.show()
X.shape, Y.shape
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
### On Fabrique u
u = np.array([X[0], X[0]**2, X[0]**3, X[1], X[1]**2, X[1]**3,
X[2], X[2]**2, X[2]**3,])
u_t = np.array([X_t[0], X_t[0]**2, X_t[0]**3, X_t[1], X_t[1]**2, X_t[1]**3,
X_t[2], X_t[2]**2, X_t[2]**3,])
### Classifier
#clf = SVC()
###clf = RandomForestClassifier(n_estimators=7000, max_depth=20, random_state=0)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(pd.DataFrame(u).T, Y)
print('Score Train : ', clf.score(pd.DataFrame(u).T, Y))
print('Score Test : ', clf.score(pd.DataFrame(u_t).T, Y_t))
#clf.fit(X_train, Y)
#print('Score Train : ', clf.score(X_train, Y))
#print('Score Test : ', clf.score(X_test, Y_t))
# 0.2684
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
### Classifier
###clf = SVC()
###clf = RandomForestClassifier(n_estimators=7000, max_depth=20, random_state=0)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train_tf, Y)
print('Score Train : ', clf.score(X_train_tf, Y))
print('Score Test : ', clf.score(X_test_tf, Y_t))
###0.3578
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
### Classifier
###clf = SVC()
#clf = RandomForestClassifier(n_estimators=7000, max_depth=20, random_state=0)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train, Y)
print('Score Train : ', clf.score(X_train, Y))
print('Score Test : ', clf.score(X_test, Y_t))
###Score Test : 0.3631
###0.3368
Il semble que la modélisation via une Classification de Logistic Régression apporte de bons résultats assez rapides.
Nous allons pouvoir prendre ce modèle pour tester les paramètres de traitement d'image les plus adaptés, le tout plus rapidement.
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=False,
is_resize_into=True,
SIZE_GLOBAL=SIZE
)clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train_tf, Y)
Score Train : 0.5610079575596817
Score Test : 0.3526315789473684
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=False,
is_resize_into=True,
SIZE_GLOBAL=SIZE
)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train_tf, Y)
Score Train : 0.5663129973474801
Score Test : 0.35789473684210527
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train, Y)
Score Train : 0.5875331564986738
Score Test : 0.3631578947368421
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=False,
is_resize_into=True,
SIZE_GLOBAL=SIZE
)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train, Y)
Score Train : 0.5079575596816976
Score Test : 0.3
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=False,
is_resize_into=True,
SIZE_GLOBAL=SIZE
)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train_tf, Y)
Score Train : 0.5397877984084881
Score Test : 0.2894736842105263
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=False,
is_resize_into=XX, FALSE
SIZE_GLOBAL=SIZE
)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train, Y)
Score Train : 0.5291777188328912
Score Test : 0.30526315789473685
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=XX, TRUE
is_resize_into=XX, FALSE
SIZE_GLOBAL=SIZE
)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train, Y)
Score Train : 0.4973474801061008
Score Test : 0.28421052631578947
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=XX, TRUE
is_resize_into=XX, FALSE
SIZE_GLOBAL=SIZE
)
clf = LogisticRegression(solver='lbfgs', multi_class='multinomial', penalty='l2')
clf.fit(X_train, Y)
Score Train : 0.5159151193633952
Score Test : 0.2578947368421053
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=XX, TRUE
is_resize_into=XX, FALSE
SIZE_GLOBAL=SIZE
)
desc=desc,
name=image_name,
rep_path=path1,
is_crop=True,
is_resize=True,
is_blur=True,
is_Inline=True,
BLUR_SIZE=5,
BLUR_SIGMAX=BLUR_SIGMAX,
is_equalizeHist=XX, TRUE
is_resize_into=XX, FALSE
SIZE_GLOBAL=SIZE
)
Le groupe B apporte le meilleur résultat
is_crop=True, is_resize=True, is_blur=True, is_Inline=True, BLUR_SIZE=5, BLUR_SIGMAX=BLUR_SIGMAX, is_equalizeHist=False, is_resize_into=True, SIZE_GLOBAL=SIZE ) BLUR = 0.5 Pas de Whitening
Nous appliquons donc ces transformations pour toutes les données que nous avons à notre disposition:
- crop par rapport aux cadres donnés - resize en (280, 280) avec conservation des proportions - Blur avec un ecart type de 0.5 - pas d'application d'égalisation d'histogramme